Image classification with CNN

1. Importing

#!pip install piexif

%load_ext autoreload
%autoreload

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.image as mpimg
from PIL import Image
import piexif

import os
import errno
import shutil

from tensorflow.keras.preprocessing.image import smart_resize
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, BatchNormalization
from tensorflow.keras.layers import Dense, Flatten, Dropout
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import Callback

from utils import join_path, rotate_image, plot_transforms, join_path_list


import matplotlib.pyplot as plt
plt.style.use('dark_background')

#from google.colab import drive
#drive.mount('/content/drive')

2. Manipulating training data

2.1 Create folders for training and validation data

def join_path(path_1='', path_2=''):
    return os.path.join(path_1, path_2).replace('\\', '/')

def create_folder(path='', folder_name=''):
    try:
        os.mkdir(os.path.join(path, folder_name).replace('\\', '/'))
    except OSError as e:
        if e.errno==errno.EEXIST:
            print('Dierctory not created, already exists')
        else:
            raise

project_path = r'C:\Users\jan\projects\tymbark_ase'
#project_path = r'\content\drive\My Drive\projects\tymbark_ase'

project_path = join_path(project_path)
raw_data = 'original_data'

raw_data_path = join_path(project_path, raw_data)

modeling_data_dir = 'modeling_data'
training_dir = 'train'
validation_dir = 'validation'


modeling_data_path = join_path(project_path, modeling_data_dir)
training_path = join_path(modeling_data_path, training_dir)
validation_path = join_path(modeling_data_path, validation_dir)

classes = os.listdir(raw_data_path)

try:
    shutil.rmtree(modeling_data_path)
except FileNotFoundError:
    pass

create_folder(project_path, 'modeling_data')
create_folder(modeling_data_path, training_dir)
create_folder(modeling_data_path, validation_dir)

for dataset in [training_path, validation_path]:
    for label in classes:
        create_folder(dataset, label)

2.2 Copy data to folders

def split(files_dir='', split_frac=0.8, seed=None):
    examples = pd.Series(os.listdir(files_dir))
    
    train = examples.sample(frac=split_frac, random_state=seed).to_list()
    val = examples.loc[~examples.isin(train)].to_list()
    
    return train, val


def join_path_list(path='', list_of_paths=[]):
    return [join_path(path, photo) for photo in list_of_paths]


def copy_file_list(list_of_paths=[], dest_dir=''):
    for file in list_of_paths: shutil.copy2(file, dest_dir)
        
        
def copy_split(classes_folders_path='', train_dir='',
               val_dir='', split_frac=0.8, seed=None):
    
    for label in classes:
        
        class_data_path = join_path(classes_folders_path, label)
        
        train_fnames, val_fnames = split(class_data_path, split_frac=split_frac, seed=seed)
        
        train_fpaths = join_path_list(class_data_path, train_fnames)
        val_fpaths = join_path_list(class_data_path, val_fnames)
        
        copy_file_list(train_fpaths, join_path(train_dir, label))
        copy_file_list(val_fpaths, join_path(val_dir, label))
        
        
copy_split(raw_data_path, training_path, validation_path, split_frac=0.7, seed=2)    

2.3 Rename files

def rename_files(classes_dir_path='', dataset_name=str):
    
    for label in os.listdir(classes_dir_path):
        class_dir = join_path(classes_dir_path, label)
        class_fnames = os.listdir(class_dir)

        
        for file_no, file_name in enumerate(class_fnames, 1):
            os.rename(join_path(class_dir, file_name),
                      join_path(class_dir, dataset_name + '_'  + label + '_' + str(file_no) + file_name[-4:]))

            
rename_files(training_path, 'train')
rename_files(validation_path, 'val')

3. Exploring data

3.1. Basic info

3.1.1. Numer of images in each class for training and validation

for label in classes:
    for dir_name, path in zip([training_dir, validation_dir],
                          [training_path, validation_path]):
        
        image_names = pd.Series(os.listdir(join_path(path, label)))
        no_of_images = image_names.shape[0]
        ex_names = image_names.sample(n=3).to_list()
        
        print(label, '|', dir_name, no_of_images, ex_names)
        #os.listdir(join_path(path, lablel))
        
    if label == classes[-1]: pass
    else: print('\n')

cyt_mie | train 50 ['train_cyt_mie_19.jpg', 'train_cyt_mie_5.jpg', 'train_cyt_mie_35.JPG']
cyt_mie | validation 22 ['val_cyt_mie_14.JPG', 'val_cyt_mie_2.jpg', 'val_cyt_mie_12.JPG']


jab_arb | train 51 ['train_jab_arb_18.jpg', 'train_jab_arb_32.JPG', 'train_jab_arb_12.jpg']
jab_arb | validation 22 ['val_jab_arb_20.JPG', 'val_jab_arb_10.JPG', 'val_jab_arb_12.JPG']


jab_brz | train 50 ['train_jab_brz_33.JPG', 'train_jab_brz_2.jpg', 'train_jab_brz_37.JPG']
jab_brz | validation 22 ['val_jab_brz_17.JPG', 'val_jab_brz_22.JPG', 'val_jab_brz_3.jpg']


jab_mie | train 50 ['train_jab_mie_4.jpg', 'train_jab_mie_12.jpg', 'train_jab_mie_27.jpg']
jab_mie | validation 22 ['val_jab_mie_14.JPG', 'val_jab_mie_9.jpg', 'val_jab_mie_5.jpg']


jab_wis | train 50 ['train_jab_wis_10.jpg', 'train_jab_wis_4.jpg', 'train_jab_wis_29.JPG']
jab_wis | validation 22 ['val_jab_wis_19.JPG', 'val_jab_wis_18.JPG', 'val_jab_wis_12.JPG']


man_mie | train 50 ['train_man_mie_30.JPG', 'train_man_mie_28.JPG', 'train_man_mie_17.jpg']
man_mie | validation 22 ['val_man_mie_20.JPG', 'val_man_mie_15.JPG', 'val_man_mie_12.JPG']


pom_brz | train 50 ['train_pom_brz_48.JPG', 'train_pom_brz_47.JPG', 'train_pom_brz_20.jpg']
pom_brz | validation 22 ['val_pom_brz_8.JPG', 'val_pom_brz_3.jpg', 'val_pom_brz_20.JPG']

3.1.2. Shapes of images, file format, orientation

def chceck_exif(image):
    
    try:
        orientation = piexif.load(image.info['exif'])['0th'][piexif.ImageIFD.Orientation]
    except KeyError:
        orientation = 'no data'
    finally:
        return orientation
        

def count_shapes(labels_dirs_path=''):
    
    columns = ['width', 'height', 'channels', 'format', 'orientation']
    shapes_df = pd.DataFrame(np.zeros(len(columns)), index=columns).T

    labels = os.listdir(labels_dirs_path)
    
    for label in labels:
        
        label_path = join_path(labels_dirs_path, label)
        fnames = os.listdir(label_path)
        fpaths = join_path_list(label_path, fnames)
        
        for fpath in fpaths:
            
            image = Image.open(fpath)
            shape = image.size
            mode = image.mode
            file_format = image.format
            orientation = chceck_exif(image)

            image_info = list(shape)
            image_info = image_info + [mode, file_format, orientation]
            iamge_info = pd.DataFrame(image_info, index=columns).T
            
            shapes_df = pd.concat([shapes_df, iamge_info])
            
    shapes_df.reset_index(inplace=True, drop=True)
    shapes_df = shapes_df.iloc[1:, :]
    shapes_df['count'] = 1
    shapes_df = shapes_df.groupby(columns).sum().reset_index()
        
    return shapes_df
        
    
print('Traing images info:')
display(count_shapes(training_path))
print('Validation images info:')
display(count_shapes(validation_path))

Traing images info:

	width	height	channels	format	orientation	count
0	3264	2448	RGB	JPEG	6	24
1	3840	2160	RGB	JPEG	6	173
2	4608	3456	RGB	JPEG	6	154

Validation images info:

	width	height	channels	format	orientation	count
0	3264	2448	RGB	JPEG	6	3
1	3840	2160	RGB	JPEG	6	97
2	4608	3456	RGB	JPEG	6	54

3.2 Ploting examples of images

def rotate_image(image_path, rotations=3):
    
    im = mpimg.imread(image_path)
    rgb = []
    
    for channel in range(im.shape[2]):
        im_channel = im[:, :, channel]
        im_channel = np.rot90(im_channel, rotations)
        rgb.append(im_channel)
 
    rotated_im = np.dstack((rgb[0], rgb[1], rgb[2]))
    
    return rotated_im



def plot_example_images(rows=3, samples=4, classes_dirs_path='', labels=[],
                        figsize=[14, 8], rotations=3):
    
    fig, axs = plt.subplots(nrows=rows, ncols=samples, figsize=figsize)
    
    row = 0
    
    for label in labels:
        label_path = join_path(training_path, label)
        images_paths = pd.Series(join_path_list(
                            label_path,
                            os.listdir(label_path))).sample(samples).to_list()
        
        
        for image_index, image, in enumerate(images_paths):
            
            im = mpimg.imread(image)
            
            if pd.Series([rotations]).isin([1, 2, 3]).values[0]:
                im = rotate_image(image, rotations=rotations)
            
            axs[row][image_index].imshow(im)
            axs[row][image_index].axis('off')  
            
        row += 1
            
    plt.show()

paths = plot_example_images(rows=len(classes), samples=4, classes_dirs_path=training_path,
                            labels=classes, figsize=[14, 14], rotations=0)

print('Rotated images')

paths = plot_example_images(rows=len(classes), samples=4, classes_dirs_path=training_path,
                            labels=classes, figsize=[10, 20], rotations=3)

Rotated images

4. Data preprocessing

4.1 Reshape images

target_shape = [256, 256]

def resize_images(classes_dirs_path='', shape=target_shape):
    for label in os.listdir(classes_dirs_path):
        class_dir_path = join_path(classes_dirs_path, label)
        images_paths = join_path_list(class_dir_path, os.listdir(class_dir_path))
    
        for image in images_paths:
            Image.open(image).resize(shape).save(image)
    
    
resize_images(training_path)
resize_images(validation_path)    

4.2 Rotate images

def rotate_and_save(classes_dirs_path='', rotations=3):
    
    for folder in os.listdir(classes_dirs_path):
        labels_folder = join_path(classes_dirs_path, folder)
        labels_paths = join_path_list(labels_folder, os.listdir(labels_folder))
        
        for im_path in labels_paths:
            rotated_im = rotate_image(im_path, rotations=rotations)
            Image.fromarray(rotated_im).save(im_path)

            
rotate_and_save(training_path)
rotate_and_save(validation_path)

print('Traing images info:')
display(count_shapes(training_path))
print('Validation images info:')
display(count_shapes(validation_path))

Traing images info:

	width	height	channels	format	orientation	count
0	256	256	RGB	JPEG	no data	351

Validation images info:

	width	height	channels	format	orientation	count
0	256	256	RGB	JPEG	no data	154

plot_example_images(rows=len(classes), samples=4, classes_dirs_path=validation_path,
                    labels=classes, figsize=[11, 19], rotations=0)

4.3 Defining ImageDataGenerator

#target_shape = [256, 256]

train_datagen = ImageDataGenerator(
        rescale=1/255,
        rotation_range=60,
        width_shift_range=0.1,
        height_shift_range=0.1,
        fill_mode='constant',
        cval=90,
        brightness_range=(0.80, 1.20),
        shear_range=10,
        zoom_range=0.1,
        channel_shift_range=30,
        zca_whitening=False,
        horizontal_flip=False,
        vertical_flip=False)

#train_datagen = ImageDataGenerator(
#        rescale=1/255)

validation_datagen = ImageDataGenerator(
        rescale=1/255)


train_gen = train_datagen.flow_from_directory(
        training_path,
        target_size=target_shape,
        batch_size=27,
        class_mode='categorical')

validation_gen = validation_datagen.flow_from_directory(
        validation_path,
        target_size=target_shape,
        batch_size=22,
        class_mode='categorical')

Found 351 images belonging to 7 classes.
Found 154 images belonging to 7 classes.

5. Modeling

5.1 Defining model

model = Sequential()

model.add(Conv2D(64, [3, 3], activation='relu', input_shape=target_shape + [3]))
model.add(MaxPooling2D(2, 2))
model.add(BatchNormalization())
model.add(Dropout(0.5))


model.add(Conv2D(128, [3, 3], activation='relu'))
model.add(MaxPooling2D(2, 2))
model.add(BatchNormalization())
model.add(Dropout(0.5))


model.add(Conv2D(256, [3, 3], activation='relu'))
model.add(MaxPooling2D(2, 2))
model.add(BatchNormalization())
model.add(Dropout(0.5))


model.add(Conv2D(512, [3, 3], activation='relu'))
model.add(MaxPooling2D(2, 2))
model.add(BatchNormalization())
model.add(Dropout(0.5))

model.add(Flatten())
model.add(Dropout(0.5))
model.add(BatchNormalization())
          
#model.add(Dense(128, activation='relu'))
#model.add(Dropout(0.5))
#model.add(BatchNormalization())

#model.add(Dense(64, activation='relu'))
#model.add(Dropout(0.5))
#model.add(BatchNormalization())

model.add(Dense(len(classes), activation='softmax'))

class MyCallback(Callback):
    def on_epoch_end(self, epoch, logs={}):
        
        desired_acc = np.round(60 / 60, 2)
        
        if logs['val_accuracy'] >= desired_acc:
            print('Reached', desired_acc, 'accuracy, stopping training')
            self.model.stop_training = True

adam_optimizer = Adam(learning_rate=0.0001)

model.compile(optimizer=adam_optimizer,
              loss='categorical_crossentropy',
              metrics=['accuracy'])

model.summary()

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 254, 254, 64)      1792      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 127, 127, 64)      0         
_________________________________________________________________
batch_normalization (BatchNo (None, 127, 127, 64)      256       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 125, 125, 128)     73856     
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 62, 62, 128)       0         
_________________________________________________________________
batch_normalization_1 (Batch (None, 62, 62, 128)       512       
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 60, 60, 256)       295168    
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 30, 30, 256)       0         
_________________________________________________________________
batch_normalization_2 (Batch (None, 30, 30, 256)       1024      
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 28, 28, 512)       1180160   
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 14, 14, 512)       0         
_________________________________________________________________
batch_normalization_3 (Batch (None, 14, 14, 512)       2048      
_________________________________________________________________
flatten (Flatten)            (None, 100352)            0         
_________________________________________________________________
dropout (Dropout)            (None, 100352)            0         
_________________________________________________________________
batch_normalization_4 (Batch (None, 100352)            401408    
_________________________________________________________________
dense (Dense)                (None, 7)                 702471    
=================================================================
Total params: 2,658,695
Trainable params: 2,456,071
Non-trainable params: 202,624
_________________________________________________________________

5.2 Training

%%time
epochs = 100
stop_train_acc = MyCallback()


history = model.fit(
    train_gen, validation_data=validation_gen, epochs=epochs, verbose=2,
    callbacks=[])

Epoch 1/100
13/13 - 20s - loss: 2.1195 - accuracy: 0.3105 - val_loss: 1.9440 - val_accuracy: 0.1429
Epoch 2/100
13/13 - 8s - loss: 1.4816 - accuracy: 0.4729 - val_loss: 1.9769 - val_accuracy: 0.1429
Epoch 3/100
13/13 - 8s - loss: 1.2994 - accuracy: 0.5385 - val_loss: 2.0563 - val_accuracy: 0.1429
Epoch 4/100
13/13 - 9s - loss: 1.1644 - accuracy: 0.5812 - val_loss: 2.0855 - val_accuracy: 0.1429
Epoch 5/100
13/13 - 8s - loss: 1.2401 - accuracy: 0.5499 - val_loss: 2.2420 - val_accuracy: 0.1429
Epoch 6/100
13/13 - 9s - loss: 1.0094 - accuracy: 0.6239 - val_loss: 2.3341 - val_accuracy: 0.1429
Epoch 7/100
13/13 - 9s - loss: 0.8609 - accuracy: 0.6695 - val_loss: 2.2821 - val_accuracy: 0.1429
Epoch 8/100
13/13 - 8s - loss: 0.9660 - accuracy: 0.6610 - val_loss: 2.4779 - val_accuracy: 0.1429
Epoch 9/100
13/13 - 8s - loss: 0.9000 - accuracy: 0.6809 - val_loss: 2.4131 - val_accuracy: 0.1558
Epoch 10/100
13/13 - 8s - loss: 1.0540 - accuracy: 0.6667 - val_loss: 2.2449 - val_accuracy: 0.1429
Epoch 11/100
13/13 - 8s - loss: 0.8276 - accuracy: 0.6895 - val_loss: 2.5444 - val_accuracy: 0.1429
Epoch 12/100
13/13 - 8s - loss: 0.8206 - accuracy: 0.6980 - val_loss: 2.6995 - val_accuracy: 0.1429
Epoch 13/100
13/13 - 8s - loss: 0.9184 - accuracy: 0.7009 - val_loss: 2.2119 - val_accuracy: 0.1558
Epoch 14/100
13/13 - 8s - loss: 0.8155 - accuracy: 0.7208 - val_loss: 2.3070 - val_accuracy: 0.1623
Epoch 15/100
13/13 - 9s - loss: 0.8305 - accuracy: 0.7265 - val_loss: 2.5756 - val_accuracy: 0.2273
Epoch 16/100
13/13 - 10s - loss: 0.6996 - accuracy: 0.7265 - val_loss: 2.5545 - val_accuracy: 0.1948
Epoch 17/100
13/13 - 10s - loss: 0.7492 - accuracy: 0.7265 - val_loss: 3.1060 - val_accuracy: 0.1494
Epoch 18/100
13/13 - 9s - loss: 0.7234 - accuracy: 0.7293 - val_loss: 2.7323 - val_accuracy: 0.1883
Epoch 19/100
13/13 - 9s - loss: 0.7246 - accuracy: 0.7721 - val_loss: 2.8777 - val_accuracy: 0.1753
Epoch 20/100
13/13 - 9s - loss: 0.6820 - accuracy: 0.7664 - val_loss: 2.2360 - val_accuracy: 0.3636
Epoch 21/100
13/13 - 8s - loss: 0.8237 - accuracy: 0.7265 - val_loss: 2.4869 - val_accuracy: 0.3961
Epoch 22/100
13/13 - 8s - loss: 0.7755 - accuracy: 0.7407 - val_loss: 2.7716 - val_accuracy: 0.2208
Epoch 23/100
13/13 - 9s - loss: 0.5992 - accuracy: 0.7863 - val_loss: 2.2709 - val_accuracy: 0.3636
Epoch 24/100
13/13 - 8s - loss: 0.7088 - accuracy: 0.7464 - val_loss: 2.0346 - val_accuracy: 0.3506
Epoch 25/100
13/13 - 8s - loss: 0.6427 - accuracy: 0.7806 - val_loss: 2.1516 - val_accuracy: 0.2792
Epoch 26/100
13/13 - 8s - loss: 0.7212 - accuracy: 0.7521 - val_loss: 2.3274 - val_accuracy: 0.3247
Epoch 27/100
13/13 - 9s - loss: 0.6914 - accuracy: 0.7692 - val_loss: 2.6402 - val_accuracy: 0.2078
Epoch 28/100
13/13 - 10s - loss: 0.5543 - accuracy: 0.7977 - val_loss: 2.2930 - val_accuracy: 0.3571
Epoch 29/100
13/13 - 10s - loss: 0.5146 - accuracy: 0.8063 - val_loss: 2.1176 - val_accuracy: 0.5130
Epoch 30/100
13/13 - 9s - loss: 0.5588 - accuracy: 0.8034 - val_loss: 2.0103 - val_accuracy: 0.4610
Epoch 31/100
13/13 - 8s - loss: 0.4351 - accuracy: 0.8405 - val_loss: 1.9418 - val_accuracy: 0.5195
Epoch 32/100
13/13 - 8s - loss: 0.6942 - accuracy: 0.7835 - val_loss: 2.2513 - val_accuracy: 0.4351
Epoch 33/100
13/13 - 9s - loss: 0.6247 - accuracy: 0.7977 - val_loss: 1.9511 - val_accuracy: 0.4740
Epoch 34/100
13/13 - 10s - loss: 0.6049 - accuracy: 0.8205 - val_loss: 1.8361 - val_accuracy: 0.4805
Epoch 35/100
13/13 - 9s - loss: 0.4213 - accuracy: 0.8575 - val_loss: 2.1186 - val_accuracy: 0.5065
Epoch 36/100
13/13 - 9s - loss: 0.5078 - accuracy: 0.8205 - val_loss: 1.3433 - val_accuracy: 0.6039
Epoch 37/100
13/13 - 8s - loss: 0.5717 - accuracy: 0.8205 - val_loss: 1.9640 - val_accuracy: 0.4156
Epoch 38/100
13/13 - 8s - loss: 0.5134 - accuracy: 0.8177 - val_loss: 1.3919 - val_accuracy: 0.5649
Epoch 39/100
13/13 - 8s - loss: 0.5254 - accuracy: 0.8348 - val_loss: 1.6247 - val_accuracy: 0.5649
Epoch 40/100
13/13 - 8s - loss: 0.5333 - accuracy: 0.8234 - val_loss: 1.3649 - val_accuracy: 0.5974
Epoch 41/100
13/13 - 9s - loss: 0.4429 - accuracy: 0.8490 - val_loss: 1.1947 - val_accuracy: 0.6039
Epoch 42/100
13/13 - 9s - loss: 0.6594 - accuracy: 0.7977 - val_loss: 0.9423 - val_accuracy: 0.6494
Epoch 43/100
13/13 - 9s - loss: 0.5298 - accuracy: 0.8120 - val_loss: 1.1197 - val_accuracy: 0.6688
Epoch 44/100
13/13 - 9s - loss: 0.4994 - accuracy: 0.8376 - val_loss: 1.1372 - val_accuracy: 0.6364
Epoch 45/100
13/13 - 8s - loss: 0.3180 - accuracy: 0.8917 - val_loss: 1.3390 - val_accuracy: 0.5779
Epoch 46/100
13/13 - 8s - loss: 0.4517 - accuracy: 0.8433 - val_loss: 0.6793 - val_accuracy: 0.7532
Epoch 47/100
13/13 - 9s - loss: 0.6509 - accuracy: 0.7920 - val_loss: 0.9190 - val_accuracy: 0.7078
Epoch 48/100
13/13 - 9s - loss: 0.3841 - accuracy: 0.8689 - val_loss: 0.7552 - val_accuracy: 0.7208
Epoch 49/100
13/13 - 9s - loss: 0.3771 - accuracy: 0.8575 - val_loss: 0.7509 - val_accuracy: 0.7532
Epoch 50/100
13/13 - 8s - loss: 0.4634 - accuracy: 0.8462 - val_loss: 0.7077 - val_accuracy: 0.7532
Epoch 51/100
13/13 - 9s - loss: 0.4039 - accuracy: 0.8689 - val_loss: 0.5677 - val_accuracy: 0.8182
Epoch 52/100
13/13 - 9s - loss: 0.3571 - accuracy: 0.8661 - val_loss: 0.4612 - val_accuracy: 0.8442
Epoch 53/100
13/13 - 8s - loss: 0.5077 - accuracy: 0.8262 - val_loss: 0.5679 - val_accuracy: 0.8247
Epoch 54/100
13/13 - 8s - loss: 0.4987 - accuracy: 0.8405 - val_loss: 0.6024 - val_accuracy: 0.8312
Epoch 55/100
13/13 - 8s - loss: 0.3886 - accuracy: 0.8661 - val_loss: 0.5262 - val_accuracy: 0.8182
Epoch 56/100
13/13 - 8s - loss: 0.4682 - accuracy: 0.8348 - val_loss: 0.5584 - val_accuracy: 0.7922
Epoch 57/100
13/13 - 8s - loss: 0.3822 - accuracy: 0.8604 - val_loss: 0.4631 - val_accuracy: 0.8442
Epoch 58/100
13/13 - 9s - loss: 0.4563 - accuracy: 0.8433 - val_loss: 0.4625 - val_accuracy: 0.8571
Epoch 59/100
13/13 - 8s - loss: 0.4372 - accuracy: 0.8632 - val_loss: 0.4569 - val_accuracy: 0.8506
Epoch 60/100
13/13 - 8s - loss: 0.3567 - accuracy: 0.8775 - val_loss: 0.3872 - val_accuracy: 0.8766
Epoch 61/100
13/13 - 8s - loss: 0.4043 - accuracy: 0.8547 - val_loss: 0.4693 - val_accuracy: 0.8312
Epoch 62/100
13/13 - 8s - loss: 0.4321 - accuracy: 0.8689 - val_loss: 0.6616 - val_accuracy: 0.8247
Epoch 63/100
13/13 - 8s - loss: 0.3807 - accuracy: 0.8689 - val_loss: 0.4302 - val_accuracy: 0.8247
Epoch 64/100
13/13 - 9s - loss: 0.4102 - accuracy: 0.8860 - val_loss: 0.9416 - val_accuracy: 0.7532
Epoch 65/100
13/13 - 9s - loss: 0.4360 - accuracy: 0.8604 - val_loss: 0.5929 - val_accuracy: 0.8247
Epoch 66/100
13/13 - 8s - loss: 0.4553 - accuracy: 0.8575 - val_loss: 0.7780 - val_accuracy: 0.7987
Epoch 67/100
13/13 - 9s - loss: 0.3742 - accuracy: 0.8860 - val_loss: 0.6364 - val_accuracy: 0.8377
Epoch 68/100
13/13 - 9s - loss: 0.3264 - accuracy: 0.8860 - val_loss: 0.8080 - val_accuracy: 0.7922
Epoch 69/100
13/13 - 8s - loss: 0.3697 - accuracy: 0.8775 - val_loss: 0.4974 - val_accuracy: 0.8636
Epoch 70/100
13/13 - 8s - loss: 0.4123 - accuracy: 0.8604 - val_loss: 0.5874 - val_accuracy: 0.8182
Epoch 71/100
13/13 - 8s - loss: 0.4125 - accuracy: 0.8860 - val_loss: 0.4673 - val_accuracy: 0.8636
Epoch 72/100
13/13 - 8s - loss: 0.3762 - accuracy: 0.8860 - val_loss: 0.5112 - val_accuracy: 0.8701
Epoch 73/100
13/13 - 9s - loss: 0.3876 - accuracy: 0.8575 - val_loss: 0.4534 - val_accuracy: 0.8701
Epoch 74/100
13/13 - 9s - loss: 0.4804 - accuracy: 0.8376 - val_loss: 0.4158 - val_accuracy: 0.8636
Epoch 75/100
13/13 - 8s - loss: 0.4304 - accuracy: 0.8632 - val_loss: 0.4277 - val_accuracy: 0.8831
Epoch 76/100
13/13 - 8s - loss: 0.2804 - accuracy: 0.9088 - val_loss: 0.4875 - val_accuracy: 0.8506
Epoch 77/100
13/13 - 8s - loss: 0.3294 - accuracy: 0.8832 - val_loss: 0.8466 - val_accuracy: 0.8117
Epoch 78/100
13/13 - 8s - loss: 0.3641 - accuracy: 0.8832 - val_loss: 0.5250 - val_accuracy: 0.8766
Epoch 79/100
13/13 - 8s - loss: 0.3415 - accuracy: 0.8746 - val_loss: 0.6579 - val_accuracy: 0.8052
Epoch 80/100
13/13 - 10s - loss: 0.3334 - accuracy: 0.8974 - val_loss: 0.7778 - val_accuracy: 0.8442
Epoch 81/100
13/13 - 9s - loss: 0.3519 - accuracy: 0.8917 - val_loss: 0.7342 - val_accuracy: 0.8506
Epoch 82/100
13/13 - 8s - loss: 0.3780 - accuracy: 0.8860 - val_loss: 0.5456 - val_accuracy: 0.8506
Epoch 83/100
13/13 - 8s - loss: 0.3092 - accuracy: 0.8917 - val_loss: 0.4981 - val_accuracy: 0.8636
Epoch 84/100
13/13 - 8s - loss: 0.2956 - accuracy: 0.9031 - val_loss: 0.9376 - val_accuracy: 0.8052
Epoch 85/100
13/13 - 8s - loss: 0.2787 - accuracy: 0.9259 - val_loss: 0.6593 - val_accuracy: 0.8377
Epoch 86/100
13/13 - 8s - loss: 0.2659 - accuracy: 0.9031 - val_loss: 0.3788 - val_accuracy: 0.8766
Epoch 87/100
13/13 - 8s - loss: 0.2814 - accuracy: 0.8917 - val_loss: 0.5587 - val_accuracy: 0.8377
Epoch 88/100
13/13 - 8s - loss: 0.1961 - accuracy: 0.9288 - val_loss: 0.4387 - val_accuracy: 0.8896
Epoch 89/100
13/13 - 9s - loss: 0.2893 - accuracy: 0.9060 - val_loss: 0.4732 - val_accuracy: 0.8961
Epoch 90/100
13/13 - 8s - loss: 0.4142 - accuracy: 0.8946 - val_loss: 0.5608 - val_accuracy: 0.8377
Epoch 91/100
13/13 - 8s - loss: 0.3455 - accuracy: 0.8917 - val_loss: 0.5783 - val_accuracy: 0.8442
Epoch 92/100
13/13 - 8s - loss: 0.4067 - accuracy: 0.8889 - val_loss: 0.6962 - val_accuracy: 0.8571
Epoch 93/100
13/13 - 8s - loss: 0.2335 - accuracy: 0.9145 - val_loss: 0.6757 - val_accuracy: 0.8377
Epoch 94/100
13/13 - 9s - loss: 0.2914 - accuracy: 0.9117 - val_loss: 0.7126 - val_accuracy: 0.8312
Epoch 95/100
13/13 - 8s - loss: 0.2406 - accuracy: 0.9345 - val_loss: 0.5153 - val_accuracy: 0.8701
Epoch 96/100
13/13 - 8s - loss: 0.2636 - accuracy: 0.9202 - val_loss: 0.5922 - val_accuracy: 0.8831
Epoch 97/100
13/13 - 9s - loss: 0.2667 - accuracy: 0.9202 - val_loss: 0.6407 - val_accuracy: 0.8506
Epoch 98/100
13/13 - 8s - loss: 0.3602 - accuracy: 0.8974 - val_loss: 0.4169 - val_accuracy: 0.8766
Epoch 99/100
13/13 - 8s - loss: 0.2633 - accuracy: 0.9117 - val_loss: 0.5306 - val_accuracy: 0.8571
Epoch 100/100
13/13 - 9s - loss: 0.2264 - accuracy: 0.9345 - val_loss: 0.5564 - val_accuracy: 0.8571
Wall time: 14min 20s

6. Model evaluation

6.1 Loss and accuracy plot

def process_history(history):
    
    history_df = pd.DataFrame(history.history)
    history_df['epoch'] = range(1, history_df.shape[0] + 1)
    
    melt = history_df.melt(id_vars=['epoch'], var_name='metric')
    
    melt['dataset'] = 'training'
    melt.loc[melt['metric'].str.find('val')!=-1, 'dataset'] = 'validation'
    
    melt.loc[melt['metric'].str.find('loss')!=-1, 'metric'] = 'loss'
    melt.loc[melt['metric'].str.find('accuracy')!=-1, 'metric'] = 'accuracy'
    
    return melt


def append_history(new_history, old_history_df, old_history=False):
    
    new_history_df = process_history(new_history)
    
    if old_history:
        
        new_history_df['epoch'] = new_history_df['epoch'] + old_history_df['epoch'].max()
        new_history_df = pd.concat([old_history_df, new_history_df], axis=0)
        
        return new_history_df
   
    return new_history_df

#del(history_df)

if 'history_df' in globals():
    history_df = append_history(new_history=history,
                                old_history_df=history_df,
                                old_history=True)
else:
    history_df = append_history(new_history=history,
                                old_history_df=False)
    
#history_df = append_history(new_history=history,
#                               old_history_df=False)

#t = history_df.loc[history_df['epoch']>50]
t = history_df.copy()

sns.relplot(data=t, x='epoch', y='value', row='metric', hue='dataset',
            kind='line', aspect=3, height=3,
            facet_kws={'sharey': False, 'legend_out': False})
plt.show()

6.2 Score on training and validation set

eval_train_datagen = ImageDataGenerator(rescale=1/255)
eval_validation_datagen = ImageDataGenerator(rescale=1/255)

eval_train = eval_train_datagen.flow_from_directory(
        training_path,
        target_size=target_shape,
        batch_size=24,
        class_mode='categorical',
        shuffle=False)

eval_validation = eval_validation_datagen.flow_from_directory(
        validation_path,
        target_size=target_shape,
        batch_size=12,
        class_mode='categorical',
        shuffle=False)


train_score = np.round(model.evaluate(eval_train, verbose=3), 2)
val_score = np.round(model.evaluate(eval_validation, verbose=3), 2)

print('\n')
print(f'Train_score:      loss = {train_score[0]}, accuracy = {train_score[1]}')
print(f'Validation_score: loss = {val_score[0]}, accuracy = {val_score[1]}')

Found 351 images belonging to 7 classes.
Found 154 images belonging to 7 classes.


Train_score:      loss = 0.16, accuracy = 0.95
Validation_score: loss = 0.56, accuracy = 0.86

6.3 Ploting misclassified images

def predictons_df(image_generator, model):
    
    class_names = image_generator.class_indices.keys()
    

    proba_df = pd.DataFrame(
                    model.predict(image_generator),
                    columns=class_names)

    proba_df['correct_pred'] = ((np.argmax(model.predict(image_generator), axis=1) \
                                 ==image_generator.labels) + 0).astype(np.uint8)
    
    proba_df['pred_proba'] = model.predict(image_generator).max(axis=1)
    
    proba_df['file_path'] = pd.Series(image_generator.filepaths).astype('string')
    
    
    labels_dict = {v: k  for k, v in image_generator.class_indices.items()}
    
    proba_df['correct_label'] = pd.Series(image_generator.labels).map(labels_dict)
    
    proba_df.loc[:, class_names] = proba_df.loc[:, class_names].round(2)
    proba_df.loc[:, 'pred_proba'] = proba_df.loc[:, 'pred_proba'].round(2)
    
    return proba_df


df = predictons_df(eval_train, model)

def plot_missclassified(image_generator, model, height=20, missclass=True):
    if missclass:
        pred_df = predictons_df(image_generator, model) \
                    .loc[lambda df: df['correct_pred']==0]
    else:
        pred_df = predictons_df(image_generator, model)
    
    columns = 3
    rows = int(np.ceil(pred_df.shape[0] / columns))
    
    width = 14
    #height = (70 / 14) * width
    
    fig, axs = plt.subplots(nrows=rows, ncols=columns, figsize=(width, height))
    axs = axs.flatten()
    
    for ax, example in enumerate(pred_df.iterrows()):
        fp = example[1]['file_path']
        axs[ax].imshow(mpimg.imread(fp))
        axs[ax].axis('off')
        
        labels = pred_df.columns[pred_df.columns.isin(classes)]
        
        #return example[1][labels]
        #break
        
        for label, proba, y in zip(labels, example[1][labels], range(0, 20*len(labels), 20)):
            #print(example[0])
            
            #print(pred_df.loc[example[1]])
            
            if label==pred_df.loc[example[0], 'correct_label']:
                color = 'green'
            elif proba==pred_df.loc[example[0], 'pred_proba']:
                color = 'red'
            else:
                color = 'white'
            
            
            axs[ax].annotate(f'\n{label}:', [256, 12 + y],
                             color=color, size=15.5, weight=240)
            
            axs[ax].annotate(f'{proba:21.2f}', [256, 12 + y],
                             color=color, size=15.5, weight=240)
            
        
            
        for row in pred_df.iterrows():
            for label in labels: pass
                #print(label, row[1][label])
    
    for ax in axs: ax.axis('off')
    
    plt.tight_layout()
    
    return axs

6.3.1 Misclassified on training set

axs = plot_missclassified(eval_train, model, height=20)

6.3.2 Misclassified on validation set

axs = plot_missclassified(eval_validation, model, height=26)